package com.geo.ai.config;

import lombok.Data;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * AI模型配置属性类
 * 支持多种AI模型的统一配置管理
 * 
 * @author GEO Team
 * @version 1.0.0
 */
@Data
@Component
@ConfigurationProperties(prefix = "ai.models")
public class AIModelProperties {
    
    /**
     * 模型配置映射
     */
    private Map<String, ModelConfig> configs = new HashMap<>();
    
    /**
     * 模型配置类
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class ModelConfig {
        
        /**
         * 提供商名称
         */
        private String provider;
        
        /**
         * API密钥
         */
        private String apiKey;
        
        /**
         * API端点
         */
        private String apiEndpoint;
        
        /**
         * 模型名称
         */
        private String modelName;
        
        /**
         * 模型参数
         */
        private Map<String, Object> parameters = new HashMap<>();
        
        /**
         * 最大Token数
         */
        private Integer maxTokens = 4000;
        
        /**
         * 温度参数
         */
        private Double temperature = 0.7;
        
        /**
         * 限流配置(每分钟请求数)
         */
        private Integer rateLimitRpm = 60;
        
        /**
         * 每Token成本
         */
        private Double costPerToken = 0.001;
        
        /**
         * 是否启用
         */
        private Boolean enabled = true;
        
        /**
         * 优先级(数字越小优先级越高)
         */
        private Integer priority = 1;
        
        /**
         * 超时时间(秒)
         */
        private Integer timeout = 60;
        
        /**
         * 重试次数
         */
        private Integer retryTimes = 3;
        
        /**
         * 获取参数值
         */
        public Object getParameter(String key) {
            return parameters.get(key);
        }
        
        /**
         * 获取参数值(带默认值)
         */
        public Object getParameter(String key, Object defaultValue) {
            return parameters.getOrDefault(key, defaultValue);
        }
        
        /**
         * 设置参数
         */
        public void setParameter(String key, Object value) {
            parameters.put(key, value);
        }
        
        /**
         * 检查配置是否有效
         */
        public boolean isValid() {
            return enabled && 
                   apiKey != null && !apiKey.trim().isEmpty() &&
                   apiEndpoint != null && !apiEndpoint.trim().isEmpty() &&
                   modelName != null && !modelName.trim().isEmpty();
        }
        
        /**
         * 获取成本预估
         */
        public double estimateCost(int tokenCount) {
            return tokenCount * costPerToken;
        }
        
        /**
         * 获取提供商名称
         * @return 提供商名称
         */
        public String getProvider() {
            return provider;
        }
        
        /**
         * 获取优先级
         * @return 优先级
         */
        public Integer getPriority() {
            return priority;
        }
        
        /**
         * 获取每Token成本
         * @return 每Token成本
         */
        public Double getCostPerToken() {
            return costPerToken;
        }
    }
    
    /**
     * 根据提供商获取配置
     */
    public ModelConfig getConfigByProvider(String provider) {
        return configs.values().stream()
                .filter(config -> provider.equalsIgnoreCase(config.getProvider()))
                .filter(ModelConfig::isValid)
                .findFirst()
                .orElse(null);
    }
    
    /**
     * 获取启用的配置列表
     */
    public Map<String, ModelConfig> getEnabledConfigs() {
        Map<String, ModelConfig> enabledConfigs = new HashMap<>();
        configs.forEach((key, config) -> {
            if (config.isValid()) {
                enabledConfigs.put(key, config);
            }
        });
        return enabledConfigs;
    }
    
    /**
     * 根据优先级获取最佳配置
     */
    public ModelConfig getBestConfig() {
        return configs.values().stream()
                .filter(ModelConfig::isValid)
                .min((c1, c2) -> Integer.compare(c1.getPriority(), c2.getPriority()))
                .orElse(null);
    }
    
    /**
     * 根据成本获取最优配置
     */
    public ModelConfig getCheapestConfig() {
        return configs.values().stream()
                .filter(ModelConfig::isValid)
                .min((c1, c2) -> Double.compare(c1.getCostPerToken(), c2.getCostPerToken()))
                .orElse(null);
    }
    
    /**
     * 计算总体配置质量分数
     */
    public double calculateQualityScore() {
        if (configs.isEmpty()) {
            return 0.0;
        }
        
        long enabledCount = configs.values().stream()
                .mapToLong(config -> config.isValid() ? 1 : 0)
                .sum();
        
        double enabledRatio = (double) enabledCount / configs.size();
        double diversityScore = Math.min(configs.size() / 4.0, 1.0); // 4个模型为满分
        
        return (enabledRatio * 0.7 + diversityScore * 0.3) * 100;
    }
}